home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / dummy_thread.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-29  |  5KB  |  168 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. '''Drop-in replacement for the thread module.
  5.  
  6. Meant to be used as a brain-dead substitute so that threaded code does
  7. not need to be rewritten for when the thread module is not present.
  8.  
  9. Suggested usage is::
  10.  
  11.     try:
  12.         import thread
  13.     except ImportError:
  14.         import dummy_thread as thread
  15.  
  16. '''
  17. __author__ = 'Brett Cannon'
  18. __email__ = 'brett@python.org'
  19. __all__ = [
  20.     'error',
  21.     'start_new_thread',
  22.     'exit',
  23.     'get_ident',
  24.     'allocate_lock',
  25.     'interrupt_main',
  26.     'LockType']
  27. import traceback as _traceback
  28. import warnings
  29.  
  30. class error(Exception):
  31.     '''Dummy implementation of thread.error.'''
  32.     
  33.     def __init__(self, *args):
  34.         self.args = args
  35.  
  36.  
  37.  
  38. def start_new_thread(function, args, kwargs = { }):
  39.     '''Dummy implementation of thread.start_new_thread().
  40.  
  41.     Compatibility is maintained by making sure that ``args`` is a
  42.     tuple and ``kwargs`` is a dictionary.  If an exception is raised
  43.     and it is SystemExit (which can be done by thread.exit()) it is
  44.     caught and nothing is done; all other exceptions are printed out
  45.     by using traceback.print_exc().
  46.  
  47.     If the executed function calls interrupt_main the KeyboardInterrupt will be
  48.     raised when the function returns.
  49.  
  50.     '''
  51.     global _main, _interrupt
  52.     if type(args) != type(tuple()):
  53.         raise TypeError('2nd arg must be a tuple')
  54.     
  55.     if type(kwargs) != type(dict()):
  56.         raise TypeError('3rd arg must be a dict')
  57.     
  58.     _main = False
  59.     
  60.     try:
  61.         function(*args, **kwargs)
  62.     except SystemExit:
  63.         pass
  64.     except:
  65.         _traceback.print_exc()
  66.  
  67.     _main = True
  68.     if _interrupt:
  69.         _interrupt = False
  70.         raise KeyboardInterrupt
  71.     
  72.  
  73.  
  74. def exit():
  75.     '''Dummy implementation of thread.exit().'''
  76.     raise SystemExit
  77.  
  78.  
  79. def get_ident():
  80.     '''Dummy implementation of thread.get_ident().
  81.  
  82.     Since this module should only be used when threadmodule is not
  83.     available, it is safe to assume that the current process is the
  84.     only thread.  Thus a constant can be safely returned.
  85.     '''
  86.     return -1
  87.  
  88.  
  89. def allocate_lock():
  90.     '''Dummy implementation of thread.allocate_lock().'''
  91.     return LockType()
  92.  
  93.  
  94. def stack_size(size = None):
  95.     '''Dummy implementation of thread.stack_size().'''
  96.     if size is not None:
  97.         raise error('setting thread stack size not supported')
  98.     
  99.     return 0
  100.  
  101.  
  102. class LockType(object):
  103.     '''Class implementing dummy implementation of thread.LockType.
  104.  
  105.     Compatibility is maintained by maintaining self.locked_status
  106.     which is a boolean that stores the state of the lock.  Pickling of
  107.     the lock, though, should not be done since if the thread module is
  108.     then used with an unpickled ``lock()`` from here problems could
  109.     occur from this class not having atomic methods.
  110.  
  111.     '''
  112.     
  113.     def __init__(self):
  114.         self.locked_status = False
  115.  
  116.     
  117.     def acquire(self, waitflag = None):
  118.         """Dummy implementation of acquire().
  119.  
  120.         For blocking calls, self.locked_status is automatically set to
  121.         True and returned appropriately based on value of
  122.         ``waitflag``.  If it is non-blocking, then the value is
  123.         actually checked and not set if it is already acquired.  This
  124.         is all done so that threading.Condition's assert statements
  125.         aren't triggered and throw a little fit.
  126.  
  127.         """
  128.         if waitflag is None or waitflag:
  129.             self.locked_status = True
  130.             return True
  131.         elif not self.locked_status:
  132.             self.locked_status = True
  133.             return True
  134.         else:
  135.             return False
  136.  
  137.     __enter__ = acquire
  138.     
  139.     def __exit__(self, typ, val, tb):
  140.         self.release()
  141.  
  142.     
  143.     def release(self):
  144.         '''Release the dummy lock.'''
  145.         if not self.locked_status:
  146.             raise error
  147.         
  148.         self.locked_status = False
  149.         return True
  150.  
  151.     
  152.     def locked(self):
  153.         return self.locked_status
  154.  
  155.  
  156. _interrupt = False
  157. _main = True
  158.  
  159. def interrupt_main():
  160.     '''Set _interrupt flag to True to have start_new_thread raise
  161.     KeyboardInterrupt upon exiting.'''
  162.     global _interrupt
  163.     if _main:
  164.         raise KeyboardInterrupt
  165.     else:
  166.         _interrupt = True
  167.  
  168.